/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package tesis.common.util;

import java.util.Date;
import java.util.List;
import tesis.domain.*;
import tesis.dto.in.*;
import tesis.dto.util.Constantes;
import tesis.dto.util.TipoEstacionEnum;




public class ConvertBeanUtil {
    
     private ConvertBeanUtil() {
    }

     
      public static Conexion convertConexionDTOtoEntity(ConexionDTO conexionDTO , List<Estacion> lstEstaciones) {
        Conexion conexion = new Conexion();
        conexion.setIdconexion(conexionDTO.getIdConexion());
        conexion.setEsalterna(conexionDTO.getEsAlterna().charAt(0));
        for(Estacion e: lstEstaciones){
            if(conexionDTO.getIdEstacionInicio().compareTo(e.getIdtemp())== 0){
                conexion.setIdestacioninicio(e);
                //if (!e.getConexionListI().contains(conexion)){
                    e.getConexionListI().add(conexion);
                //}
            }else{
                if(conexionDTO.getIdEstacionFin().compareTo(e.getIdtemp())== 0){
                    conexion.setIdestacionfin(e);
                    //if (!e.getConexionListF().contains(conexion)){
                        e.getConexionListF().add(conexion);
                    //}
                }
            }
        }
        
     
        return conexion;
    }
     
     
     public static Estacion convertEstacionDTOtoEntity(EstacionDTO estacionDTO){
            
         Estacion estacion = new Estacion();
         /*if (estacionDTO.getIdEstacion()==null)
             estacionDTO.setIdEstacion(GregorianCalendar.getInstance().hashCode());*/
         
         if(estacionDTO.getIdTipoEstacion()==TipoEstacionEnum.INICIO.getValue()){
             estacion.setIdtipoestacion(new TipoEstacion(TipoEstacionEnum.INICIO.getValue()));
             estacion.setIdcargo(new Cargo(Constantes.SIN_CARGO));
             estacion.setTiempolimite(0);
         }else {
             if(estacionDTO.getIdTipoEstacion()==TipoEstacionEnum.FIN.getValue()){
                  estacion.setIdtipoestacion(new TipoEstacion(TipoEstacionEnum.FIN.getValue()));
                  estacion.setIdcargo(new Cargo(Constantes.SIN_CARGO));
                  estacion.setTiempolimite(0);
             }else{
                 estacion.setIdtipoestacion(new TipoEstacion(TipoEstacionEnum.ATENDIBLE.getValue()));
                 estacion.setIdcargo(new Cargo(estacionDTO.getIdCargo()));
                 estacion.setTiempolimite(estacionDTO.getTiempoLimite());
             }
         }
         
         estacion.setIdestacion(estacionDTO.getIdEstacion());
         estacion.setIdtemp(estacionDTO.getIdTemp());
         estacion.setNombre(estacionDTO.getNombre());
         estacion.setIdproceso(new Proceso(estacionDTO.getIdProceso()));
         estacion.setDireccionformulario(estacionDTO.getFormulario()!=null?estacionDTO.getFormulario():"-");
         return estacion;
     }
     
     
     
    public static Variable convertVariableDTOtoEntity(VariableDTO variableDTO) {
        Variable variable = new Variable();
        //variable.setIdvariable(variableDTO.getIdvariable());
        variable.setNombre(variableDTO.getNombre());
        variable.setDescripcion("-");
        variable.setIdtipodato(convertTipoDatoDTOtoEntity(variableDTO.getTipoDatoDTO())); 
        variable.setIdproceso(new Proceso(variableDTO.getIdProceso()));
        variable.setIdTemp(variableDTO.getIdvariable());
        return variable;
    }
    
    public static Documento convertDocumentoDTOtoEntity(DocumentoDTO documentoDTO){
        Documento documento = new Documento();
        documento.setDescripcion(documentoDTO.getDescripcion());
        documento.setFechacreacion(new Date());
        documento.setIdtipodocumento(convertTipoDocumentoDTOtoEntity(documentoDTO.getIdtipodocumentoDTO()));
        documento.setIndactivo(Constantes.ACTIVO.charAt(0));
        documento.setNombre(documentoDTO.getNombre());
        documento.setRutadocumento(documentoDTO.getRutadocumento());      
        return documento;
    }
    
    
    public static TipoDato convertTipoDatoDTOtoEntity(TipoDatoDTO tipoDatoDTO){
        TipoDato tipoDato = new TipoDato();
        tipoDato.setIdtipodato(tipoDatoDTO.getIdtipodato());
        return tipoDato;
    }
    
    
    
    public static TipoDocumento convertTipoDocumentoDTOtoEntity( TipoDocumentoDTO tipoDocumentoDTO){
        TipoDocumento tipoDocumento = new TipoDocumento();
        //tipoDocumento.setIdtipodocumento(tipoDocumentoDTO.getIdTipoDocumento());
        tipoDocumento.setNombre(tipoDocumentoDTO.getNombre());
        tipoDocumento.setDescripcion(tipoDocumentoDTO.getDescripcion()); 
        tipoDocumento.setIdproceso(new Proceso(tipoDocumentoDTO.getIdProceso()));
        tipoDocumento.setIdTemp(tipoDocumentoDTO.getIdTipoDocumento());
        if (!CollectionsUtil.isEmpty(tipoDocumentoDTO.getLstEstadoDocumentoDTO())){
            for (EstadoDocumentoDTO e:tipoDocumentoDTO.getLstEstadoDocumentoDTO()){
                EstadoDocumento est=convertEstadoDocumentoDTOtoEntity(e);
                est.setIdtipodocumento(tipoDocumento);
                tipoDocumento.getEstadoDocumentoList().add(est);
            }
        }
        return tipoDocumento;
    }
    
    public static EstadoDocumento convertEstadoDocumentoDTOtoEntity(EstadoDocumentoDTO estadoDocumentoDTO) {
        
        EstadoDocumento estadoDocumento = new EstadoDocumento();
        
        estadoDocumento.setIdestadodocumento(estadoDocumentoDTO.getIdestadodocumento());
        estadoDocumento.setNombre(estadoDocumentoDTO.getNombre());
        estadoDocumento.setDescripcion(estadoDocumentoDTO.getDescripcion());
        estadoDocumento.setEsactivo('A');
        estadoDocumento.setIdTemp(estadoDocumentoDTO.getIdestadodocumentoTemp());
        return estadoDocumento;
    }
    
    public static Proceso convertProcesoDTOtoEntity(ProcesoDTO procesoDTO){
        Proceso proceso=new Proceso();
        
        proceso.setIdproceso(procesoDTO.getIdProceso());
        proceso.setNombre(procesoDTO.getNombre());
        proceso.setIdcategoriaproceso(new CategoriaProceso(procesoDTO.getIdCategoriaProceso()));
        proceso.setVersion(procesoDTO.getVersion());
        
        /*ESTACIONES*/
        if (!CollectionsUtil.isEmpty(procesoDTO.getLstEstaciones())){
            Estacion estacion=null;
            for (EstacionDTO e:procesoDTO.getLstEstaciones()){
                estacion=convertEstacionDTOtoEntity(e);
                estacion.setIdproceso(proceso);
                proceso.getEstacionList().add(estacion);
            }
        }
        
        /*CONEXIONES*/
        List<Estacion> estc=proceso.getEstacionList();
        if (!CollectionsUtil.isEmpty(procesoDTO.getLstConexiones())){
            for(ConexionDTO c:procesoDTO.getLstConexiones()){
                convertConexionDTOtoEntity(c, estc);
            }
        }
        
        /*DOCUMENTOS*/
        List<TipoDocumentoDTO> docs=procesoDTO.getLstDocumentos();
        if (!CollectionsUtil.isEmpty(docs)){
            TipoDocumento documento=null;
            for(TipoDocumentoDTO d: docs){
                documento=convertTipoDocumentoDTOtoEntity(d);
                proceso.getTipoDocumentoList().add(documento);
                documento.setIdproceso(proceso);
            }
        }
        
        /*VARIABLES*/
         List<VariableDTO> vars=procesoDTO.getLstVariables();
         if (!CollectionsUtil.isEmpty(vars)){
            Variable var=null;
            for(VariableDTO v: vars){
                var=convertVariableDTOtoEntity(v);
                proceso.getVariableList().add(var);
                var.setIdproceso(proceso);
            }
         }
        
         /*REGLAS*/
         for (EstacionDTO e:procesoDTO.getLstEstaciones()){
            if (!CollectionsUtil.isEmpty(e.getLstReglas())){
                Regla regla=null;
                for (ReglaDTO r: e.getLstReglas()){
                    regla=convertReglaDTOtoEntity(r,estc,proceso.getVariableList(),proceso.getTipoDocumentoList());
                }
            }
        }
         
         
        
        return proceso;
    }
    
     public static Regla convertReglaDTOtoEntity(ReglaDTO reglaDTO, List<Estacion> lstEstaciones,List<Variable> vars,List<TipoDocumento> docs) {
        Regla regla = new Regla();
        regla.setIdtiporegla(new TipoRegla(reglaDTO.getTipoRegla().getIdTipoRegla()));
        regla.setNombre("regla nombre");
         for(Estacion e: lstEstaciones){
            if(reglaDTO.getIdEstacion().compareTo(e.getIdtemp())== 0){
                regla.setIdestacion(e);
                
                /*variables*/
                if (!CollectionsUtil.isEmpty(reglaDTO.getParametroVariableList())){
                    for (ParametroVariableDTO p:reglaDTO.getParametroVariableList()){
                        convertParametroVariableDTOtoEntity(p, regla, vars);
                    }
                }
                
                /*documentos*/
                if (!CollectionsUtil.isEmpty(reglaDTO.getParametroDocumentoList())){
                    for (ParametroDocumentoDTO d:reglaDTO.getParametroDocumentoList()){
                        convertParametroDocumentoDTOtoEntity(d, regla, docs);
                    }
                }
                
                
                e.getReglaList().add(regla);
                
                //para cada conexion de salida 
                if (!CollectionsUtil.isEmpty(e.getConexionListI())){
                    for (Conexion c:e.getConexionListI()){
                        if (c.getEsalterna()=='Y'){
                            ConexionEstacionregla cer=new ConexionEstacionregla();
                            cer.setIdregla(regla);
                            cer.setIdestacion(c.getIdestacionfin());
                            cer.setIdconexion(c);
                            
                            for (SalidaAlternaDTO sa:reglaDTO.getSalidaAlternaList()){
                                if (sa.getIdTempEstacion().equals(c.getIdestacionfin().getIdtemp())){
                                    cer.setEsverdadera(sa.getEsVerdadera().charAt(0));
                                }
                            }
                            regla.getConexionEstacionreglaList().add(cer);
                        }
                    }
                }
                
            }
        }
        return regla;
    }
     
     public static ReglaXParametroVariable convertParametroVariableDTOtoEntity(ParametroVariableDTO parametroDTO,Regla regla,List<Variable> vars){
         ReglaXParametroVariable rxp=new ReglaXParametroVariable();
         ParametroVariable param=new ParametroVariable();
         EstacionXVarible exv=new EstacionXVarible();
         
         param.setIdtipocomparacion(new TipoComparacion(parametroDTO.getComparacion()));
         if (parametroDTO.getValorComparacion()!=null && !parametroDTO.getValorComparacion().equals(""))
            param.setValorcomparacion(parametroDTO.getValorComparacion());
         if (parametroDTO.getValorActualizado()!=null && !parametroDTO.getValorActualizado().equals("")){
            param.setValoractualizado(parametroDTO.getValorActualizado());
            param.setIdtipocomparacion(new TipoComparacion(Constantes.ID_ASIGNACION));
         }
         
         if (parametroDTO.getEsVerdadera()!=null
             && !parametroDTO.getEsVerdadera().equals("-"))
            param.setEsverdadera(parametroDTO.getEsVerdadera().charAt(0));
         
         rxp.setIdregla(regla);
         rxp.setEsentrada(parametroDTO.getEsEntrada().charAt(0));
         exv.setIdestacion(regla.getIdestacion());

         for(Variable v: vars){
            if( parametroDTO.getIdTipoDato().compareTo(v.getIdTemp())==0){
                rxp.setIdparamentrovariable(param);
                regla.getReglaXParametroVariableList().add(rxp);
                exv.setIdvariable(v);
                v.getEstacionXVaribleList().add(exv);
                break;
            }
         }
        
         exv.getParametroVariableList().add(param);
         param.setIdestacionvariable(exv);
         return rxp;
     }
     
     public static ReglaXParametroDocumento convertParametroDocumentoDTOtoEntity(ParametroDocumentoDTO parametroDTO,Regla regla,List<TipoDocumento> docs){
         ReglaXParametroDocumento rxd=new ReglaXParametroDocumento();
         ParametroDocumento param=new ParametroDocumento();
         EstacionXTipoDocumento exd=new EstacionXTipoDocumento();
         
         if (parametroDTO.getEsVerdadera()!=null
             && !parametroDTO.getEsVerdadera().equals("-"))
            param.setEsverdadera(parametroDTO.getEsVerdadera().charAt(0));
         
         rxd.setIdregla(regla);
         rxd.setEsentrada(parametroDTO.getEsEntrada().charAt(0));
         exd.setIdestacion(regla.getIdestacion());

         for(TipoDocumento d: docs){
            if( parametroDTO.getIdTipoDocumento().compareTo(d.getIdTemp())==0){
                rxd.setIdparametrodocumento(param);
                regla.getReglaXParametroDocumentoList().add(rxd);
                exd.setIdtipodocumento(d);
                d.getEstacionXTipoDocumentoList().add(exd);
                //tipo de comparacion y valor a comparar
                param.setIdtipocomparacion(new TipoComparacion(Constantes.ID_IGUAL));
                
                for(EstadoDocumento e: d.getEstadoDocumentoList()){
                    if( parametroDTO.getIdEstadoDocumento().toString().equals(e.getIdTemp())){
                        param.setValorcomparacion(e);
                        param.setValoractualizado(e);
                        break;
                    }
                }
            
                
                break;
            }
         }
        
         exd.getParametroDocumentoList().add(param);
         param.setIdestaciontipodocumento(exd);
         return rxd;
     }
    
     public static UsuarioDTO toUsuarioDTO(Usuario usuario) {
        UsuarioDTO dto=new UsuarioDTO();
        dto.setAnexo(usuario.getAnexo());
        dto.setApellidomaterno(usuario.getApellidomaterno());
        dto.setApellidopaterno(usuario.getApellidopaterno());
        dto.setCargalaboral(usuario.getCargalaboral());
        dto.setCelular(usuario.getCelular());
        dto.setEmail(usuario.getEmail());
        dto.setEsactivo(usuario.getEsactivo());
        dto.setIdusuario(usuario.getIdusuario());
        dto.setNombre(usuario.getNombre());
        dto.setTelefono(usuario.getTelefono());
        dto.setUsuario(usuario.getUsuario());
        if(!CollectionsUtil.isEmpty(usuario.getUsuarioXCargoList()))
        for(UsuarioXCargo e : usuario.getUsuarioXCargoList()){
            if(e.getIdcargo().getEsactivo() == Constantes.ACTIVO.charAt(0)){
                dto.setCargoDTO(toCargoDTO(e.getIdcargo()));
            }
        }
        
        return dto;
     }
     
     public static TipoDatoDTO toTipoDatoDTO(TipoDato tipodato) {
        TipoDatoDTO tipoDTO=new TipoDatoDTO(tipodato.getIdtipodato(),tipodato.getNombretipodato(),tipodato.getNombretipodato());
        return tipoDTO;
     }
     
     public static CargoDTO toCargoDTO(Cargo cargo) {
        CargoDTO cargoDTO=new CargoDTO();
        cargoDTO.setIdCargo(cargo.getIdcargo());
        cargoDTO.setEsActivo(String.valueOf(cargo.getEsactivo()));
        cargoDTO.setFechaCreacion(cargo.getFechacreacion());
        for(Nombrecargo nombreCargo : cargo.getNombrecargoList()){
            if(String.valueOf(nombreCargo.getEsactivo()).equals(Constantes.ACTIVO)){
                cargoDTO.setNombre(nombreCargo.getNombre());
                cargoDTO.setDescripcion(nombreCargo.getDescripcion());
                break;
            }
        }       

        return cargoDTO;
     }
     
     public static MapaSincronizadoDTO toMapaSincDTO(MapaSincronizado mapa, boolean conJSON){
        MapaSincronizadoDTO mapaDTO=new MapaSincronizadoDTO();
        mapaDTO.setId(mapa.getId());
        mapaDTO.setNombreProceso(mapa.getNombre());
        mapaDTO.setEstado(mapa.getEstado());
        mapaDTO.setFecha(DateUtil.formatDDMMYYHH(mapa.getFecha()));
        if (conJSON){
            mapaDTO.setData(mapa.getDatamodelada());
            mapaDTO.setLienzo(mapa.getLienzo());
        }
        return mapaDTO;
     }
     
     
      public static ProcesoDTO toProcesoDTO(Proceso proceso) {
        ProcesoDTO dto=new ProcesoDTO();
        dto.setIdProceso(proceso.getIdproceso());
        dto.setNombre(proceso.getNombre());
        dto.setEsActivo(proceso.getIndactivo()+"");
        dto.setVersion(proceso.getVersion());
        if (!CollectionsUtil.isEmpty(proceso.getEstacionList())){
            for (Estacion e:proceso.getEstacionList()){
                dto.getLstEstaciones().add(toEstacionDTO(e));
            }
        }
        
        return dto;
     }
      
      
        public static ProcesoDTO toProcesoLightDTO(Proceso proceso) {
        ProcesoDTO dto=new ProcesoDTO();
        dto.setIdProceso(proceso.getIdproceso());
        dto.setNombre(proceso.getNombre());
        dto.setEsActivo(proceso.getIndactivo()+"");
        dto.setVersion(proceso.getVersion());  
        dto.setFecha(DateUtil.formatDDMMYYHH(proceso.getFechainstalacion()));
        return dto;
     }
        
     public static EstacionDTO toEstacionDTO(Estacion estacion) {
         EstacionDTO dto=new  EstacionDTO();
         dto.setIdEstacion(estacion.getIdestacion());
         dto.setNombre(estacion.getNombre());
         dto.setIdProceso(estacion.getIdproceso().getIdproceso());
         dto.setIdTipoEstacion(estacion.getIdtipoestacion().getIdtipoestacion());
         if (!CollectionsUtil.isEmpty(estacion.getReglaList())){
             for (Regla r:estacion.getReglaList()){
                 dto.getLstReglas().add(toReglaDTO(r));
             }
         }
         return dto;
     }
     
     public static ReglaDTO toReglaDTO(Regla regla){
         ReglaDTO dto=new ReglaDTO();
         dto.setIdRegla(regla.getIdregla());
         dto.setTipoRegla(new TipoReglaDTO(regla.getIdtiporegla().getIdtiporegla()));
         return dto;
     }
      
      public static InstanciaEstacionDTO toInstanciaEstacionDTO(InstanciaEstacion instancia){
          InstanciaEstacionDTO dto = new InstanciaEstacionDTO();
          dto.setIdinstanciaestacion(instancia.getIdinstanciaestacion());
          dto.setFechacreacion(instancia.getFechacreacion());
          dto.setFechatermino(instancia.getFechatermino());
          dto.setNombreEstacion(instancia.getIdestacion().getNombre());
          dto.setUsuario(toUsuarioDTO(instancia.getIdusuario()));
          dto.setTiempoLimite(instancia.getIdestacion().getTiempolimite());
          dto.setUrl(instancia.getIdestacion().getDireccionformulario());
          dto.setStrFechaCreacion(DateUtil.formatDDMMYYHH(instancia.getFechacreacion()));
          dto.setInstanciaProceso(toInstanciaProcesoDTO(instancia.getIdinstanciaproceso()));
          dto.setNombreProceso(instancia.getIdinstanciaproceso().getIdproceso().getNombre());
          dto.setIdProceso(instancia.getIdinstanciaproceso().getIdproceso().getIdproceso());
          if (instancia.getFechatermino()!=null){
              dto.setStrFechaTermino(DateUtil.formatDDMMYYHH(instancia.getFechatermino()));
          }
          if (instancia.getFechacreacion()!=null){
              dto.setStrFechaCreacion(DateUtil.formatDDMMYYHH(instancia.getFechacreacion()));
          }
          if (instancia.getEstadoInstanciaEstacionXInstanciaEstacionList()!=null){
              for (EstadoInstanciaEstacionXInstanciaEstacion e:instancia.getEstadoInstanciaEstacionXInstanciaEstacionList()){
                   EstadoInstanciaEstacionDTO estado= toEstadoInstanciaEstacionDTO(e.getIdestadoinstanciaestacion());
                   dto.setEstadoDTO(estado);
              }
          }
          //faltaria  traer datos de variables y documentos
          //instancia.getInstanciaEstacionXParametroVariableList()
                  
          return dto;
      }
      
      
      
      public static TipoDocumentoDTO toTipoDocumentoDTO(TipoDocumento tDocumento){
          
          TipoDocumentoDTO dto = new TipoDocumentoDTO();
          dto.setIdTipoDocumento(tDocumento.getIdtipodocumento());
          dto.setDescripcion(tDocumento.getDescripcion());
          dto.setNombre(tDocumento.getNombre());
          dto.setIdProceso(tDocumento.getIdproceso().getIdproceso());
          if(tDocumento.getEstadoDocumentoList().size()!= 0){
              for(EstadoDocumento e:tDocumento.getEstadoDocumentoList()){
                  if(e.getEsactivo() == Constantes.ACTIVO.charAt(0) )
                  dto.getLstEstadoDocumentoDTO().add(toEstadoDocumentoDTO(e));
              }
          }
          
          
          return dto;
      }
      
      public static EstadoDocumentoDTO toEstadoDocumentoDTO(EstadoDocumento tEstadoDocumento){
          EstadoDocumentoDTO dto = new EstadoDocumentoDTO();
          dto.setIdestadodocumento(tEstadoDocumento.getIdestadodocumento());
          dto.setNombre(tEstadoDocumento.getNombre());
          dto.setDescripcion(tEstadoDocumento.getDescripcion()); 
          return dto;
      }
      
      public static VariableDTO toVariableDTO(Variable variable){
          
          VariableDTO dto = new VariableDTO();
          dto.setIdProceso(variable.getIdproceso().getIdproceso());
          dto.setIdvariable(variable.getIdvariable());
          dto.setNombre(variable.getNombre());
          dto.setDescripcion(variable.getDescripcion());
          dto.setTipoDatoDTO(toTipoDatoDTO(variable.getIdtipodato()));
          return dto;
      }
      
      public static InstanciaProcesoDTO toInstanciaProcesoDTO(InstanciaProceso instancia){
          InstanciaProcesoDTO bean = new InstanciaProcesoDTO();
          bean.setFechacreacion(instancia.getFechacreacion());
          bean.setFechatermino(instancia.getFechatermino());
          bean.setIdinstanciaproceso(instancia.getIdinstanciaproceso());
          bean.setIdproceso(instancia.getIdproceso().getIdproceso());
          bean.setIndactivo(instancia.getIndactivo());
          bean.setVersionMapaProceso(instancia.getIdproceso().getVersion());
          if(!CollectionsUtil.isEmpty(instancia.getExpedienteList())){
            for(Expediente e: instancia.getExpedienteList()){
                bean.getExpedienteList().add(toExpedienteDTO(e));
            }
          }
          return bean;
          
      }
      
      public static ExpedienteDTO toExpedienteDTO(Expediente expediente){
          ExpedienteDTO bean = new ExpedienteDTO();
          bean.setCodigoexpediente(expediente.getCodigoexpediente());
          bean.setFechacreacion(expediente.getFechacreacion());
          bean.setIdexpediente(expediente.getIdexpediente());
          
          return bean;
          
      }
      
      
      
      public static EstadoInstanciaEstacionDTO toEstadoInstanciaEstacionDTO(EstadoInstanciaEstacion estadoInst){
          EstadoInstanciaEstacionDTO bean = new EstadoInstanciaEstacionDTO();
          bean.setIdestadoinstanciaestacion(estadoInst.getIdestadoinstanciaestacion());
          bean.setNombre(estadoInst.getNombre());
          bean.setDescripcion(estadoInst.getDescripcion());
          return bean;
      }
     
}
